import {
	getMonthOfAdd,
	getNowDateTime,
	getNowMonth
} from '@/utils/utils.js';
import {
	add,
	eq,
	gt,
	gteq,
	lt,
	negate,
	sub
} from '@/utils/math-utils.js';

/**
 * 获取某时间内的收支记录 - 收支记录表
 * @description 转账交易，仅展示，不计入金额统计
 * @param {string} date 日期 yyyy-MM-dd、yyyy-MM
 * @param {number} payType 0 全部 1 收入 2 支出 3 转账
 * @param {string} cashType 收支分类
 * @return {object} {'list': [],'total': '0'}
 */
export function getCashLogListForDate(date, payType = 0, cashType = '', pageNum = 0, pageSize = 0) {
	// 最长日期格式 2025-04-15
	date = date.slice(0, 10)
	let list = uni.getStorageSync('db_cash_log')
	if (!list) {
		return {
			'list': [],
			'total': '0'
		}
	}

	// 按时间倒序排序
	list.sort((a, b) => b.payTime > a.payTime ? 1 : -1);

	let total = '0'
	// 条件过滤
	let filteredList = []
	for (const item of list) {
		if ((payType == 0 || item.payType == payType) &&
			(date == '' || item.payTime.startsWith(date)) &&
			(cashType == '' || item.cashType == cashType)) {
			filteredList.push(item)
			// 转账一加一减，相当于0，不计入收支总额
			if (item.payType != 3) {
				total = add(total, item.money)
			}
		}
	}
	// 关联图标
	let cashTypeList = uni.getStorageSync('db_cash_type')
	for (let info of filteredList) {
		let foundCashType = cashTypeList.find(item => item.payType == info.payType && item.cashType == info.cashType);
		if (foundCashType) {
			info.icon = foundCashType.icon
		} else {
			info.icon = '/static/image/cash_type/jb.png'
		}
	}

	// 返回数据
	if (pageSize > 0) {
		let start = pageNum * pageSize
		let end = start + pageSize
		let currList = filteredList.slice(start, end)
		return {
			'list': currList,
			'total': total
		}
	}

	return {
		'list': filteredList,
		'total': total
	}
}

/**
 * 统计 - 获取某月的收支记录，按天汇总 - 收支记录表
 * @description 转账交易，仅展示，不计入金额统计
 * @param {number} payType 0 全部 1 收入 2 支出 3 转账
 * @return {object} {'list': [],'total': '0','total_z': '0','total_s': '0'}
 */
export function getCashLogListForMonth(date, payType = 0) {
	// 最长日期格式 2025-04
	date = date.slice(0, 7)
	let list = uni.getStorageSync('db_cash_log')
	if (!list || date == '') {
		return {
			'list': [],
			'total': '0',
			'total_z': '0',
			'total_s': '0',
		}
	}
	// 按时间倒序排序
	list.sort((a, b) => b.payTime > a.payTime ? 1 : -1);
	let total = '0'
	let total_z = '0'
	let total_s = '0'
	// 条件过滤
	let filteredList = []
	for (const item of list) {
		if ((payType == 0 || item.payType == payType) && item.payTime.startsWith(date)) {
			filteredList.push(item)
			if (item.payType == 1) {
				total = add(total, item.money)
				total_s = add(total_s, item.money)
			} else if (item.payType == 2) {
				total = add(total, item.money)
				total_z = add(total_z, item.money)
			}
		}
	}
	// 按天汇总，同一天的，计入一条
	let resultList = []
	for (const item of filteredList) {
		// 检查当前的 payTime 是否已经存在于累加器中
		const existingItem = resultList.find(resultItem => resultItem.payTime == item.payTime.slice(0, 10));
		if (existingItem) {
			if (item.payType == 1) {
				existingItem.money = add(existingItem.money, item.money)
				existingItem.money_s = add(existingItem.money_s, item.money)
			} else if (item.payType == 2) {
				existingItem.money = add(existingItem.money, item.money)
				existingItem.money_z = add(existingItem.money_z, item.money)
			}
		} else {
			resultList.push({
				'payTime': item.payTime.slice(0, 10),
				'money': item.payType == 3 ? "0" : item.money,
				'money_z': item.payType == 2 ? item.money : '0',
				'money_s': item.payType == 1 ? item.money : '0'
			})
		}
	}

	// 返回全部数据
	return {
		'list': resultList,
		'total': total,
		'total_z': total_z,
		'total_s': total_s,
	}
}

/**
 * 统计 - 获取某年的收支记录，按月汇总 - 收支记录表
 * @description 转账交易，仅展示，不计入金额统计
 * @param {number} payType 0 全部 1 收入 2 支出 3 转账
 * @return {object} {'list': [],'total': '0','total_z': '0','total_s': '0'}
 */
export function getCashLogListForYear(date, payType = 0) {
	// 最长日期格式 2025
	date = date.slice(0, 4)
	let list = uni.getStorageSync('db_cash_log')
	if (!list || date == '') {
		return {
			'list': [],
			'total': '0',
			'total_z': '0',
			'total_s': '0',
		}
	}
	// 按时间倒序排序
	list.sort((a, b) => b.payTime > a.payTime ? 1 : -1);
	let total = '0'
	let total_z = '0'
	let total_s = '0'
	// 条件过滤
	let filteredList = []
	for (const item of list) {
		if ((payType == 0 || item.payType == payType) && item.payTime.startsWith(date)) {
			filteredList.push(item)
			if (item.payType == 1) {
				total = add(total, item.money)
				total_s = add(total_s, item.money)
			} else if (item.payType == 2) {
				total = add(total, item.money)
				total_z = add(total_z, item.money)
			}
		}
	}
	// 按月汇总，同一月的，计入一条
	let resultList = []
	for (const item of filteredList) {
		// 检查当前的 payTime 是否已经存在于累加器中
		const existingItem = resultList.find(resultItem => resultItem.payTime == item.payTime.slice(0, 7));
		if (existingItem) {
			if (item.payType == 1) {
				existingItem.money = add(existingItem.money, item.money)
				existingItem.money_s = add(existingItem.money_s, item.money)
			} else if (item.payType == 2) {
				existingItem.money = add(existingItem.money, item.money)
				existingItem.money_z = add(existingItem.money_z, item.money)
			}
		} else {
			resultList.push({
				'payTime': item.payTime.slice(0, 7),
				'money': item.payType == 3 ? "0" : item.money,
				'money_z': item.payType == 2 ? item.money : '0',
				'money_s': item.payType == 1 ? item.money : '0'
			})
		}
	}
	// 返回全部数据
	return {
		'list': resultList,
		'total': total,
		'total_z': total_z,
		'total_s': total_s,
	}
}

/**
 * 新增收支记录 - 收支记录表
 * @param {string} money 支出时金额为负数，收入时金额为正数，转账时金额为正数
 * @param {number} payType 1 收入、 2 支出、 3 转账
 * @param {string} cashType 收支分类名称
 * @param {string} account 账户名称名称
 * @return {object} {success: true,msg: 'ok'}
 */
export function saveCashLog(money, account, payType, cashType, payTime, note, account2) {
	let resultData = {
		success: true,
		msg: 'ok'
	}

	// 不管结果，先提升使用排序(优先级)
	addCashTypeSort(cashType)
	addAccountSort(account)

	if (payType == 3) {
		return saveCashLogBy3(money, account, payType, cashType, payTime, note, account2)
	}

	let checkResultData_1 = checkAccountUse(account, money)
	if (!checkResultData_1.success) {
		return checkResultData_1
	}

	let item = {
		'id': Date.now(), // 唯一id，这里用时间戳
		'money': money, // 金额 (带正负: 支付时金额为负数，收入时金额为正数，转账时金额为正数)
		'account': account, // 账户名称 (使用账户名称,名称唯一)
		'payType': payType, // 1 收入、 2 支出、 3 转账
		'account2': '', // 转账账户名称 (使用账户名称,名称唯一)
		'cashType': cashType, // 收支分类 (使用分类名称,名称唯一)
		'payTime': payTime, // 收支时间
		'note': note, // 备注
	}
	// 保存收支记录
	let list = uni.getStorageSync('db_cash_log')
	if (!list) {
		list = []
	}
	list.push(item)
	uni.setStorageSync('db_cash_log', list)
	// 更新账户
	updateAccountMoneyForPay(account, money)
	// 更新资产统计
	updateMonthAccountTotalByMonth(payTime, money)
	return resultData
}

/**
 * 新增账户互转收支记录 - 收支记录表
 * @param {string} money 支出时金额为负数，收入时金额为正数，转账时金额为正数
 * @param {string} cashType 收支分类名称
 * @param {string} account 账户名称名称
 * @return {object} {success: true,msg: 'ok'}
 */
export function saveCashLogBy3(money, account, payType, cashType, payTime, note, account2) {
	let resultData = {
		success: true,
		msg: 'ok'
	}
	if (account == account2) {
		resultData.success = false
		resultData.msg = '收付款账户不能相同'
		return resultData
	}
	let item_1 = {
		'id': Date.now() - 1, // 唯一id，这里用时间戳
		'money': money, // 金额 (支出时金额为负数，收入时金额为正数，转账时金额为正数)
		'account': account, // 账户名称 (使用账户名称,名称唯一)
		'payType': payType, // 1 收入、 2 支出、 3 转账
		'account2': account2, // 转账账户名称 (使用账户名称,名称唯一)
		'cashType': cashType, // 收支分类 (使用分类名称,名称唯一)
		'payTime': payTime, // 收支时间
		'note': note, // 备注
	}
	let checkResultData_1 = checkAccountUse(account, '-' + money)
	if (!checkResultData_1.success) {
		return checkResultData_1
	}
	let checkResultData_2 = checkAccountUse(account2, money)
	if (!checkResultData_2.success) {
		return checkResultData_2
	}

	// 保存收支记录
	let list = uni.getStorageSync('db_cash_log')
	if (!list) {
		list = []
	}
	list.push(item_1)
	uni.setStorageSync('db_cash_log', list)
	// 更新账户
	updateAccountMoneyForPay(account, '-' + money)
	updateAccountMoneyForPay(account2, money)
	// 更新净资产金额统计：账户互转，一加一减，净资产不变。历史统计不需要更改。只更新当前月资产和负债即可。
	updateCurrentMonthAccountTotal()
	return resultData
}

/**
 * 修改收支记录 - 收支记录表
 * @description 只能修改：当前月、上月
 * @param {string} money 支出时金额为负数，收入时金额为正数，转账时金额为正数
 * @param {string} cashType 收支分类名称
 * @param {string} account 账户名称名称
 * @return {object} {success: true,msg: 'ok'}
 */
export function updateCashLog(id, money, account, cashType, payTime, note, account2) {
	let resultData = {
		success: true,
		msg: 'ok'
	}

	let list = uni.getStorageSync('db_cash_log')
	if (!list) {
		list = []
	}

	let foundLog = list.find(item => item.id == id);
	if (!foundLog) {
		resultData.success = false
		resultData.msg = '交易不存在'
		return resultData
	}

	if (foundLog.payType == 3) {
		return updateCashLogBy3(id, money, account, cashType, payTime, note, account2)
	}

	if (foundLog.account != account || !eq(foundLog.money, money)) {
		// 是不是同一个账户
		if (foundLog.account != account) {
			// 不要同账户，校验旧账户金额状态 - 全额
			// 校验旧账户金额状态
			let checkResultData11 = checkAccountUse(foundLog.account, negate(foundLog.money))
			if (!checkResultData11.success) {
				return checkResultData11
			}
			// 校验新账户金额状态 - 全额
			let checkResultData12 = checkAccountUse(account, money)
			if (!checkResultData12.success) {
				return checkResultData12
			}
		} else {
			// 相同账户，校验旧账户金额状态 - 差额
			let checkResultData11 = checkAccountUse(foundLog.account, sub(money, foundLog.money))
			if (!checkResultData11.success) {
				return checkResultData11
			}
		}

		// 更新旧账户金额,全部退还
		let checkResultData_1 = updateAccountMoneyForPay(foundLog.account, negate(foundLog.money))
		if (!checkResultData_1.success) {
			return checkResultData_1
		}
		// 更新新账户金额,全部计入
		let checkResultData_2 = updateAccountMoneyForPay(account, money)
		if (!checkResultData_2.success) {
			// 回滚：归还账户金额事件
			updateAccountMoneyForPay(foundLog.account, foundLog.money)
			// 返回
			return checkResultData_2
		}
		// 更新净资产金额统计
		// 1 旧记录月份,全部退还
		updateMonthAccountTotalByMonth(foundLog.payTime, negate(foundLog.money))
		// 2 新记录月份,全部计入
		updateMonthAccountTotalByMonth(payTime, money)
	}
	foundLog.money = money
	foundLog.account = account
	foundLog.cashType = cashType
	foundLog.payTime = payTime
	foundLog.note = note
	// 保存收支记录 (foundLog 是地址引用， 不需要手动再更新)
	uni.setStorageSync('db_cash_log', list)
	return resultData
}

/**
 * 修改账户互转收支记录 - 收支记录表
 * @param {string} money 支出时金额为负数，收入时金额为正数，转账时金额为正数
 * @param {string} cashType 收支分类名称
 * @param {string} account 账户名称名称
 * @return {object} {success: true,msg: 'ok'}
 */
export function updateCashLogBy3(id, money, account, cashType, payTime, note, account2) {
	let resultData = {
		success: true,
		msg: 'ok'
	}
	if (account == account2) {
		resultData.success = false
		resultData.msg = '收付款账户不能相同'
		return resultData
	}

	let list = uni.getStorageSync('db_cash_log')
	if (!list) {
		list = []
	}

	let foundLog = list.find(item => item.id == id);
	if (foundLog) {
		if (foundLog.account != account || foundLog.account2 != account2 || !eq(foundLog.money, money)) {
			// 不区分差额了，校验全额，简单一点
			// 校验2*2个账户金额
			let checkResultData11 = checkAccountUse(foundLog.account, foundLog.money)
			if (!checkResultData11.success) {
				return checkResultData11
			}
			let checkResultData12 = checkAccountUse(foundLog.account2, negate(foundLog.money))
			if (!checkResultData12.success) {
				return checkResultData12
			}
			let checkResultData21 = checkAccountUse(account,
				foundLog.account != account ? negate(payMoney) : sub(foundLog.money, money))
			if (!checkResultData21.success) {
				return checkResultData21
			}
			let checkResultData22 = checkAccountUse(account2,
				foundLog.account2 != account2 ? payMoney : sub(money, foundLog.money))
			if (!checkResultData22.success) {
				return checkResultData22
			}

			// 归还账户金额
			updateAccountMoneyForPay(foundLog.account, foundLog.money)
			updateAccountMoneyForPay(foundLog.account2, negate(foundLog.money))
			updateAccountMoneyForPay(account, negate(money))
			updateAccountMoneyForPay(account2, money)

			// 更新净资产金额统计：账户互转，一加一减，净资产不变。历史统计不需要更改。只更新当前月资产和负债即可。
			updateCurrentMonthAccountTotal()
		}
		foundLog.money = money
		foundLog.account = account
		foundLog.cashType = cashType
		foundLog.payTime = payTime
		foundLog.note = note
		// 保存收支记录 (foundLog 是地址引用， 不需要手动再更新)
		uni.setStorageSync('db_cash_log', list)
		return resultData
	} else {
		resultData.success = false
		resultData.msg = '交易不存在'
		return resultData
	}
}

/**
 * 删除收支记录 - 收支记录表
 * @param {number} id 
 * @return {object} {success: true,msg: 'ok'}
 */
export function deleteCashLog(id) {
	let resultData = {
		success: true,
		msg: 'ok'
	}
	let list = uni.getStorageSync('db_cash_log')
	if (!list) {
		resultData.success = false
		resultData.msg = '交易不存在'
		return resultData
	}
	let foundLog = list.find(item => item.id == id);
	if (!foundLog) {
		resultData.success = false
		resultData.msg = '交易不存在'
		return resultData
	}

	// 校验账户余额状态
	if (foundLog.payType == 3) {
		let checkResultData11 = checkAccountUse(foundLog.account, foundLog.money)
		if (!checkResultData11.success) {
			return checkResultData11
		}
		let checkResultData12 = checkAccountUse(foundLog.account2, negate(foundLog.money))
		if (!checkResultData12.success) {
			return checkResultData12
		}
	} else {
		let checkResultData11 = checkAccountUse(foundLog.account, negate(foundLog.money))
		if (!checkResultData11.success) {
			return checkResultData11
		}
	}
	// 归还金额
	if (foundLog.payType == 3) {
		let updateResultData11 = updateAccountMoneyForPay(foundLog.account, foundLog.money)
		if (!updateResultData11.success) {
			return updateResultData11
		}
		let updateResultData12 = updateAccountMoneyForPay(foundLog.account2, negate(foundLog.money))
		if (!updateResultData12.success) {
			return updateResultData12
		}
	} else {
		let updateResultData11 = updateAccountMoneyForPay(foundLog.account, negate(foundLog.money))
		if (!updateResultData11.success) {
			return updateResultData11
		}
	}

	// 更新净资产金额统计
	if (foundLog.payType == 3) {
		// 账户互转，一加一减，净资产不变。历史统计不需要更改。只更新当前月资产和负债即可。
		updateCurrentMonthAccountTotal()
	} else {
		updateMonthAccountTotalByMonth(foundLog.payTime, negate(foundLog.money))
	}

	// 删除收支记录
	let filteredArr = list.filter(item => item.id != id);
	uni.setStorageSync('db_cash_log', filteredArr)
	return resultData
}

/**
 * 获取收支分类 - 收支分类表
 * @param {number} payType 0 全部  1 收入、 2 支出、 3 转账
 * @param {number} status 0 全部 1 可用
 * @return {Array} []
 */
export function getCashTypeList(payType = 0, status = 1) {
	let all_list = uni.getStorageSync('db_cash_type')
	if (!all_list) {
		all_list = []
		// 创建默认数据
		let item_1 = {
			'id': 10000001, // 唯一id，这里用时间戳
			'pid': 0, // 上级id [最大二级]
			'payType': 1, // 1 收入、 2 支出、 3 转账
			'cashType': '其他', // 收支分类
			'icon': '/static/image/cash_type/jb.png',
			'sortNum': 1, // 排序
			'status': 1, // 状态 1 可用 2 不可用
			'isDelete': 0, // 状态 1 已删除 0 正常 【删除时，同时设置不可用】
		}
		all_list.push(item_1)
		// 创建默认数据
		let item_2 = {
			'id': 10000002, // 唯一id，这里用时间戳
			'pid': 0, // 上级id [最大二级]
			'payType': 2, // 1 收入、 2 支出、 3 转账
			'cashType': '其他', // 收支分类
			'icon': '/static/image/cash_type/jb.png',
			'sortNum': 1, // 排序
			'status': 1, // 状态 1 可用 2 不可用
			'isDelete': 0, // 状态 1 已删除 0 正常 【删除时，同时设置不可用】
		}
		all_list.push(item_2)
		// 创建默认数据
		let item_3 = {
			'id': 10000003, // 唯一id，这里用时间戳
			'pid': 0, // 上级id [最大二级]
			'payType': 3, // 1 收入、 2 支出、 3 转账
			'cashType': '账户互转', // 收支分类
			'icon': '/static/image/cash_type/zz.png',
			'sortNum': 1, // 排序
			'status': 1, // 状态 1 可用 2 不可用
			'isDelete': 0, // 状态 1 已删除 0 正常 【删除时，同时设置不可用】
		}
		all_list.push(item_3)
		uni.setStorageSync('db_cash_type', all_list)
	}

	// 条件过滤
	let list = []
	list = all_list.filter(item => {
		return item.isDelete == 0 && (status == 0 || status == item.status) &&
			(payType == 0 || item.payType == payType)
	});

	return list
}

/**
 * 新增收支分类 - 收支分类表 [最大二级]
 * @param {number} payType 0 全部  1 收入、 2 支出、 3 转账
 * @param {string} cashType 收支分类名称 
 * @return {object} {success: true,msg: 'ok'}
 */
export function saveCashType(pid, payType, cashType, icon) {
	let resultData = {
		success: true,
		msg: 'ok'
	}
	let item = {
		'id': Date.now(), // 唯一id，这里用时间戳
		'pid': pid, // 上级id [最大二级]
		'payType': payType, // 1 收入、 2 支出、 3 转账
		'cashType': cashType, // 收支分类
		'icon': icon, // 收支分类图标
		'sortNum': 1, // 排序
		'status': 1, // 状态 1 可用 2 不可用
		'isDelete': 0, // 状态 1 已删除 0 正常 【删除时，同时设置不可用】
	}
	let list = uni.getStorageSync('db_cash_type')
	if (!list) {
		list = []
	}
	let foundItem = list.find(item => item.payType == payType && item.cashType == cashType);
	if (!foundItem) {
		list.push(item)
		uni.setStorageSync('db_cash_type', list)
		return resultData
	} else {
		// 如果被删除，恢复
		if (foundItem.isDelete == 1) {
			foundItem.icon = icon
			foundItem.status = 1
			foundItem.isDelete = 0
			uni.setStorageSync('db_cash_type', list)
			return resultData
		} else {
			resultData.success = false
			resultData.msg = '分类已存在'
			return resultData
		}
	}
}

/**
 * 修改收支分类名称 - 收支分类表 [最大二级]
 * @param {number} payType 0 全部  1 收入、 2 支出、 3 转账
 * @return {object} {success: true,msg: 'ok'}
 */
export function updateCashTypeName(id, cashType, icon) {
	let resultData = {
		success: true,
		msg: 'ok'
	}

	let list = uni.getStorageSync('db_cash_type')
	if (!list) {
		list = []
	}

	let foundCashType = list.find(item => item.id == id);
	if (foundCashType) {
		let foundItem = list.find(item => item.payType == foundCashType.payType && item.cashType == cashType &&
			item.id != id);
		if (foundItem) {
			resultData.success = false
			resultData.msg = '分类已存在'
			return resultData
		}

		foundCashType.cashType = cashType
		foundCashType.icon = icon
		uni.setStorageSync('db_cash_type', list)
		return resultData
	} else {
		resultData.success = false
		resultData.msg = '分类不存存在'
		return resultData
	}
}

/**
 * 提升收支分类排序
 * @param {string} cashType 分类名称
 * @return {object} {success: true,msg: 'ok'}
 */
export function addCashTypeSort(cashType) {
	let resultData = {
		success: true,
		msg: 'ok'
	}

	let list = uni.getStorageSync('db_cash_type')
	if (!list) {
		list = []
	}
	// 按排序值排序，第一个值即为最大值
	list.sort((a, b) => b.sortNum > a.sortNum ? 1 : -1)
	let max_sort = list[0].sortNum
	// 继续走
	let foundType = list.find(item => item.cashType == cashType);
	if (foundType) {
		foundType.sortNum = max_sort + 1
		uni.setStorageSync('db_cash_type', list)
		return resultData
	} else {
		resultData.success = false
		resultData.msg = '分类不存存在'
		return resultData
	}
}

/**
 * 删除收支分类 - 收支分类表
 * @param {number} id 
 * @return {object} {success: true,msg: 'ok'}
 */
export function deleteCashType(id) {
	let resultData = {
		success: true,
		msg: 'ok'
	}
	let list = uni.getStorageSync('db_cash_type')
	if (!list) {
		resultData.success = false
		resultData.msg = '分类不存在'
		return resultData
	}
	let foundType = list.find(item => item.id == id);
	if (foundType) {
		foundType.status = 2
		foundType.isDelete = 1
		uni.setStorageSync('db_cash_type', list)
		return resultData
	} else {
		resultData.success = false
		resultData.msg = '分类不存在'
		return resultData
	}
}

/**
 * 获取账户列表 - 账户表
 * @param {number} type 0 全部 1 储蓄卡 2 信用卡
 * @param {number} status 0 全部 1 可用 2 不可用
 * @return {Array} []
 */
export function getAllAccountList(type = 0, status = 0) {
	let all_list = uni.getStorageSync('db_cash_account')
	if (!all_list) {
		all_list = []
		return all_list
	}

	// 条件过滤
	let list = []
	list = all_list.filter(item => {
		return item.isDelete == 0 && (status == 0 || item.status == status) && (type == 0 || item.type ==
			type)
	});
	// 按可用/不可用排序
	list.sort((a, b) => b.status < a.status ? 1 : -1);

	return list
}

/**
 * 新增账户 - 账户表
 * @param {string} name 账户名称名称
 * @param {number} type 0 全部 1 储蓄卡 2 信用卡
 * @param {string} money 需带正负
 * @return {object} {success: true,msg: 'ok'}
 */
export function saveAccount(name, type, icon, money = '0') {
	let resultData = {
		success: true,
		msg: 'ok'
	}
	let item = {
		'id': Date.now(), // 唯一id，这里用时间戳
		'name': name, // 账户名称
		'icon': icon, // 账户名称
		'type': type, // 账户类型 1 储蓄卡 2 信用卡
		'money': money, // 账户余额
		'sortNum': 1, // 排序
		'status': 1, // 状态 1 可用 2 不可用
		'isDelete': 0, // 状态 1 已删除 0 正常 【删除时，同时设置不可用】
	}
	let list = uni.getStorageSync('db_cash_account')
	if (!list) {
		list = []
	}
	let foundAccount = list.find(item => item.name == name);
	if (!foundAccount) {
		// 创建一条收入记录
		if (!eq(money, '0')) {
			if (type == 1 && lt(money, '0')) {
				resultData.success = false
				resultData.msg = '储蓄卡账户金额不能小于0'
				return resultData
			}
			if (type == 2 && gt(money, '0')) {
				resultData.success = false
				resultData.msg = '信用卡账户金额不能大于0'
				return resultData
			}
			let item_log = {
				'id': Date.now(), // 唯一id，这里用时间戳
				'money': money, // 金额 (带正负)
				'account': name, // 账户名称 (使用账户名称,名称唯一)
				'payType': gteq(money, '0') ? 1 : 2, // 1 收入、 2 支出、 3 转账
				'cashType': '其他', // 收支分类 (使用分类名称,名称唯一)
				'payTime': getNowDateTime(), // 收支时间
				'note': '账户初始化', // 备注
			}
			// 保存收支记录
			let log_list = uni.getStorageSync('db_cash_log')
			if (!log_list) {
				log_list = []
			}
			log_list.push(item_log)
			uni.setStorageSync('db_cash_log', log_list)
		}
		list.push(item)
		uni.setStorageSync('db_cash_account', list)
		// 更新当前月账户总金额
		updateCurrentMonthAccountTotal()
		return resultData
	} else {
		// 已删除账户同名，就恢复
		if (foundAccount.isDelete == 1) {
			// 创建一条收入记录
			if (!eq(money, '0')) {
				if (type == 1 && lt(money, '0')) {
					resultData.success = false
					resultData.msg = '储蓄卡账户金额不能小于0'
					return resultData
				}
				if (type == 2 && gt(money, '0')) {
					resultData.success = false
					resultData.msg = '信用卡账户金额不能大于0'
					return resultData
				}
				let item_log = {
					'id': Date.now(), // 唯一id，这里用时间戳
					'money': money, // 金额 (带正负)
					'account': name, // 账户名称 (使用账户名称,名称唯一)
					'payType': gteq(money, '0') ? 1 : 2, // 1 收入、 2 支出、 3 转账
					'cashType': '其他', // 收支分类 (使用分类名称,名称唯一)
					'payTime': getNowDateTime(), // 收支时间
					'note': '账户初始化', // 备注
				}
				// 保存收支记录
				let log_list = uni.getStorageSync('db_cash_log')
				if (!log_list) {
					log_list = []
				}
				log_list.push(item_log)
				uni.setStorageSync('db_cash_log', log_list)
			}
			foundAccount.status = 1
			foundAccount.type = type
			foundAccount.money = money
			foundAccount.isDelete = 0
			uni.setStorageSync('db_cash_account', list)
			// 更新当前月账户资产统计
			updateCurrentMonthAccountTotal()
			return resultData
		} else {
			resultData.success = false
			resultData.msg = '账户已存在'
			return resultData
		}
	}
}

/**
 * 根据交易金额,更新账户金额 - 账户表
 * 
 * @description 内部不校验金额余额状态,只管更新
 * @param {string} account 账户名称名称
 * @param {string} payMoney 需带正负
 * @return {object} {success: true,msg: 'ok'}
 */
export function updateAccountMoneyForPay(name, payMoney) {
	let resultData = {
		success: true,
		msg: 'ok'
	}
	let list = uni.getStorageSync('db_cash_account')
	if (!list) {
		resultData.success = false
		resultData.msg = name + '账户不存在'
		return resultData
	}
	let foundAccount = list.find(item => item.name == name && item.isDelete == 0);
	if (foundAccount) {
		foundAccount.money = add(foundAccount.money, payMoney)
		// fing 返回的是引用，list也会变
		uni.setStorageSync('db_cash_account', list)
		return resultData
	} else {
		resultData.success = false
		resultData.msg = name + '账户不存在'
		return resultData
	}
}

/**
 * 更新账户总金额 - 账户表
 * @param {string} account 账户名称名称
 * @param {string} total 需带正负
 * @return {object} {success: true,msg: 'ok'}
 */
export function updateAccountTotalForName(name, icon, total) {
	let resultData = {
		success: true,
		msg: 'ok'
	}
	let list = uni.getStorageSync('db_cash_account')
	if (!list) {
		resultData.success = false
		resultData.msg = '账户不存在'
		return resultData
	}
	let foundAccount = list.find(item => item.name == name && item.isDelete == 0);
	if (foundAccount) {
		// 图标任意改
		foundAccount.icon = icon
		// find 返回的是引用，list也会变
		uni.setStorageSync('db_cash_account', list)
		// 金额
		if (foundAccount.status == 2) {
			resultData.success = false
			resultData.msg = '账户冻结中'
			return resultData
		}
		if (foundAccount.type == 1 && lt(total, '0')) {
			resultData.success = false
			resultData.msg = '储蓄卡账户金额不能小于'
			return resultData
		}
		if (foundAccount.type == 2 && gt(total, '0')) {
			resultData.success = false
			resultData.msg = '信用卡账户金额不能大于'
			return resultData
		}
		let payType = 1
		let note = ''
		// 漏记金额
		let payMoney = sub(total, foundAccount.money)
		if (eq(payMoney, '0')) {
			return resultData
		} else if (lt(payMoney, '0')) {
			payType = 2
			note = '漏记支出'
		} else {
			payType = 1
			note = '漏记收入'
		}
		// 创建交易记录
		let item_log = {
			'id': Date.now(), // 唯一id，这里用时间戳
			'money': payMoney, // 金额 (带正负)
			'account': name, // 账户名称 (使用账户名称,名称唯一)
			'payType': payType, // 1 收入、 2 支出、 3 转账
			'cashType': '其他', // 收支分类 (使用分类名称,名称唯一)
			'payTime': getNowDateTime(), // 收支时间
			'note': note, // 备注
		}
		// 保存收支记录
		let log_list = uni.getStorageSync('db_cash_log')
		if (!log_list) {
			log_list = []
		}
		log_list.push(item_log)
		uni.setStorageSync('db_cash_log', log_list)
		// 更新账户
		foundAccount.money = total
		// find 返回的是引用，list也会变
		uni.setStorageSync('db_cash_account', list)
		// 更新当前月账户资产统计
		updateCurrentMonthAccountTotal()
		return resultData
	}
}

/**
 * 提升账户排序
 * @param {string} name 账户名称
 * @return {object} {success: true,msg: 'ok'}
 */
export function addAccountSort(name) {
	let resultData = {
		success: true,
		msg: 'ok'
	}

	let list = uni.getStorageSync('db_cash_account')
	if (!list) {
		list = []
	}
	// 按排序值排序，第一个值即为最大值
	list.sort((a, b) => b.sortNum > a.sortNum ? 1 : -1)
	let max_sort = list[0].sortNum
	// 继续走
	let foundAccount = list.find(item => item.name == name);
	if (foundAccount) {
		foundAccount.sortNum = max_sort + 1
		uni.setStorageSync('db_cash_account', list)
		return resultData
	} else {
		resultData.success = false
		resultData.msg = name + '账户不存在'
		return resultData
	}
}

/**
 * 删除账户 - 账户表
 * @param {number} id 
 * @return {object} {success: true,msg: 'ok'}
 */
export function deleteAccount(id) {
	let resultData = {
		success: true,
		msg: 'ok'
	}
	let list = uni.getStorageSync('db_cash_account')
	if (!list) {
		resultData.success = false
		resultData.msg = '账户不存在'
		return resultData
	}
	let foundAccount = list.find(item => item.id == id);
	if (foundAccount) {
		if (eq(foundAccount.money, '0')) {
			foundAccount.status = 2
			foundAccount.isDelete = 1
			uni.setStorageSync('db_cash_account', list)
			return resultData
		} else {
			resultData.success = false
			resultData.msg = '账户有余额，不允许删除'
			return resultData
		}
	} else {
		resultData.success = false
		resultData.msg = '账户不存在'
		return resultData
	}
}

/**
 * 检查账户是否可用及更新后余额是否正常 - 账户表
 * @param {string} account 账户名称名称
 * @param {string} payMoney 需带正负
 * @return {object} {success: true,msg: 'ok'}
 */
export function checkAccountUse(name, payMoney) {
	let resultData = {
		success: true,
		msg: 'ok'
	}
	let list = uni.getStorageSync('db_cash_account')
	if (!list) {
		resultData.success = false
		resultData.msg = name + '账户不存在'
		return resultData
	}

	let foundAccount = list.find(item => item.name == name && item.isDelete == 0);
	if (foundAccount) {
		if (foundAccount.status == 2) {
			resultData.success = false
			resultData.msg = name + '账户冻结中'
			return resultData
		}
		if (foundAccount.type == 1 && lt(add(foundAccount.money, payMoney), '0')) {
			resultData.success = false
			resultData.msg = name + '账户金额不足'
			return resultData
		}
		if (foundAccount.type == 2 && gt(add(foundAccount.money, payMoney), '0')) {
			resultData.success = false
			resultData.msg = name + '账户金额不能大于0'
			return resultData
		}
		return resultData
	} else {
		resultData.success = false
		resultData.msg = name + '账户不存在'
		return resultData
	}
}

/**
 * 获取当前资产信息和最近12个月资产趋势（净资产，资产，负债） - 统计表
 * @return {object} {'list': [],'currTotal': {}}
 */
export function getAccountMoneyTotalForMonth() {
	let list = uni.getStorageSync('db_account_total_month')
	if (!list) {
		return {
			'list': [],
			'currTotal': {}
		}
	}
	// 按时间倒序
	list.sort((a, b) => b.month > a.month ? 1 : -1);
	// 最多12条
	let currList = list.slice(0, 12)
	// 返回数据
	return {
		'list': currList,
		'currTotal': currList[0]
	}
}

/**
 * 查询历月资产统计信息，更新历月净资产（净资产），同时包含当前月资产更新 - 月净资产统计表
 * @description 只有当前月需要更新资产、负债。历史月只有净资产。
 * @param {string} changeMoney 差额，带正负
 */
export function updateMonthAccountTotalByMonth(month, changeMoney) {
	// 最长日期格式 2025-04
	month = month.slice(0, 7)
	if (month == '') {
		return
	}

	// 不是当前月的
	if (month != getNowMonth()) {
		let month_list = uni.getStorageSync('db_account_total_month')
		if (month_list) {
			// 遍历 变动月 - 当前月 的所有月份的 净资产
			while (month < getNowMonth()) { // 字符串比较，也符合比大小结果
				let foundAccount = month_list.find(item => item.month == month);
				if (foundAccount) {
					foundAccount.total = add(foundAccount.total, changeMoney)
				}
				month = getMonthOfAdd(month, 1)
			}
			uni.setStorageSync('db_account_total_month', month_list)
		}
	}

	// 当前月数据更新 (不管哪个月资金修改，都会引起当前月的金额变动)
	updateCurrentMonthAccountTotal()
}

/**
 * 统计账户金额，更新当前月资产（净资产，资产，负债） - 月净资产统计表
 */
export function updateCurrentMonthAccountTotal() {
	let month = getNowMonth()
	let list = uni.getStorageSync('db_cash_account')
	if (!list) {
		list = []
	}
	// 计算总额
	let total = '0'
	let cxk_total = '0'
	let xyk_total = '0'
	for (const item of list) {
		// type 账户类型 1 储蓄卡 2 信用卡
		total = add(total, item.money)
		if (item.type == 1) {
			cxk_total = add(cxk_total, item.money)
		} else if (item.type == 2) {
			xyk_total = add(xyk_total, item.money)
		}
	}
	// 封装对象
	let currMonthTotal = {
		'month': month,
		'total': total,
		'xyk_total': xyk_total,
		'cxk_total': cxk_total
	}
	let month_list = uni.getStorageSync('db_account_total_month')
	if (!month_list) {
		month_list = []
		month_list.push(currMonthTotal)
	} else {
		let foundAccount = month_list.find(item => item.month == month);
		if (foundAccount) {
			foundAccount.total = total
			foundAccount.xyk_total = xyk_total
			foundAccount.cxk_total = cxk_total
		} else {
			month_list.push(currMonthTotal)
		}
	}
	uni.setStorageSync('db_account_total_month', month_list)
}